// pages/history/history.js
const dbHelper = require('../../utils/dbHelper');

Page({

    /**
     * 页面的初始数据
     */
    data: {
        userInfo: null,         // 用户信息
        isTeacher: false,       // 是否为教师角色
        activeTab: 'test',      // 当前激活的标签页
        testRecords: [],        // 测试记录列表
        consultationRecords: [], // 咨询记录列表
        loading: false,         // 加载状态
        statusText: {           // 状态文本映射
            'pending': '待审批',
            'approved': '已通过',
            'rejected': '已拒绝',
            'completed': '已完成'
        }
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        // 从本地存储获取用户信息
        const userInfo = wx.getStorageSync('userInfo');
        console.log('【历史记录】获取到用户信息:', JSON.stringify(userInfo));
        
        // 检查用户是否已登录，未登录则跳转到登录页
        if (!userInfo) {
            wx.showToast({
                title: '请先登录',
                icon: 'none',
                duration: 2000,
                success: () => {
                    setTimeout(() => {
                        wx.navigateTo({
                            url: '/pages/login/login',
                        });
                    }, 2000);
                }
            });
            return;
        }

        // 输出用户相关信息到控制台
        console.log('【历史记录】用户角色:', userInfo.role);
        console.log('【历史记录】用户班级:', userInfo.class);
        console.log('【历史记录】用户openid:', userInfo.openid);
        
        // 设置用户信息和身份标识到页面数据
        this.setData({
            userInfo: userInfo,
            isTeacher: userInfo.role === 'teacher'
        });

        // 加载历史记录数据
        this.loadRecords();
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {

    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
        // 每次页面显示时，如果用户已登录则刷新数据
        if (this.data.userInfo) {
            this.loadRecords();
        }
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {
        // 执行下拉刷新，重新加载记录数据
        this.loadRecords();
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    },

    // 切换标签页的处理函数
    switchTab(e) {
        const tab = e.currentTarget.dataset.tab;
        this.setData({
            activeTab: tab
        });
    },

    // 加载历史记录数据的核心函数
    async loadRecords() {
        console.log('【历史记录】开始加载记录数据');
        this.setData({ loading: true });
        
        try {
            const db = wx.cloud.database();
            const _ = db.command;
            
            // 获取当前用户信息
            const userInfo = this.data.userInfo;
            const userId = userInfo._id;
            
            // 获取心理测试记录
            let testRecordsQuery;

            // 教师角色获取班级学生的测试记录
            if (this.data.isTeacher) {
                // 获取教师所属班级
                const userClass = userInfo.class || (userInfo.classes && userInfo.classes.length > 0 ? userInfo.classes[0] : null);
                if (!userClass) {
                    console.log('【历史记录】辅导员未分配班级');
                    this.setData({ 
                        testRecords: [],
                        loading: false 
                    });
                    return;
                }
                
                console.log('【历史记录】获取班级学生测试记录:', userClass);
                
                // 查询该班级所有学生信息
                const studentsRes = await db.collection('users')
                    .where({
                        role: 'student',
                        class: userClass
                    }).get();
                
                // 如果班级中没有学生，显示空结果
                if (!studentsRes.data || studentsRes.data.length === 0) {
                    console.log('【历史记录】班级内没有学生');
                    this.setData({ 
                        testRecords: [],
                        loading: false 
                    });
                    return;
                }
                
                // 提取学生ID、用户名和openid信息
                const studentIds = studentsRes.data.map(s => s._id);
                const studentUsernames = studentsRes.data.map(s => s.username);
                const studentOpenids = studentsRes.data.map(s => s.openid);
                
                console.log('【历史记录】班级学生数量:', studentsRes.data.length);
                
                // 创建学生信息映射表，方便后续查找
                const studentMap = {};
                studentsRes.data.forEach(student => {
                    studentMap[student._id] = student;
                    if (student.openid) studentMap[student.openid] = student;
                    if (student.username) studentMap[student.username] = student;
                });
                
                // 查询所有符合条件的学生测试记录
                testRecordsQuery = await db.collection('psychological_tests')
                    .where(_.or([
                        { userId: _.in(studentIds) },
                        { openid: _.in(studentOpenids.filter(id => id)) },
                        { username: _.in(studentUsernames.filter(name => name)) }
                    ]))
                    .orderBy('createTime', 'desc')
                    .get();
                
                // 为每条记录添加学生姓名信息
                testRecordsQuery.data = testRecordsQuery.data.map(record => {
                    const student = record.userId ? studentMap[record.userId] : 
                                   (record.openid ? studentMap[record.openid] : 
                                   (record.username ? studentMap[record.username] : null));
                    
                    return {
                        ...record,
                        studentName: student ? student.username || student.nickName || '未知' : '未知'
                    };
                });
                
            } else {
                // 学生角色只查询自己的测试记录
                console.log('【历史记录】获取学生个人测试记录, userId:', userId, 'openid:', userInfo.openid, 'username:', userInfo.username);
                
                // 构建OR查询条件，确保能查到该学生的所有记录
                const queryConditions = [];
                
                // 添加用户ID查询条件
                if (userId) {
                    queryConditions.push({ userId: userId });
                }
                
                // 添加openid查询条件
                if (userInfo.openid) {
                    queryConditions.push({ openid: userInfo.openid });
                }
                
                // 添加用户名查询条件
                if (userInfo.username) {
                    queryConditions.push({ username: userInfo.username });
                }
                
                // 防止无条件查询返回所有记录
                if (queryConditions.length === 0) {
                    console.log('【历史记录】警告：没有可用的用户标识符进行查询');
                    queryConditions.push({ userId: 'non_existent_id' });
                }
                
                // 执行查询，按创建时间降序排序
                testRecordsQuery = await db.collection('psychological_tests')
                    .where(_.or(queryConditions))
                    .orderBy('createTime', 'desc')
                    .get();
                    
                console.log('【历史记录】获取到学生个人测试记录数量:', testRecordsQuery.data.length);
            }
            
            // 处理测试记录数据，格式化时间和计算分数
            const testRecords = testRecordsQuery.data.map(record => {
                // 格式化创建时间显示
                let formattedTime = record.createTime;
                if (record.createTime instanceof Date) {
                    formattedTime = record.createTime.toLocaleString();
                } else if (typeof record.createTime === 'string') {
                    try {
                        formattedTime = new Date(record.createTime).toLocaleString();
                    } catch(e) {
                        console.error('时间格式化错误', e);
                    }
                }
                
                // 检查并计算原始分数和最大可能分数
                let originalScore = record.originalScore;
                let maxPossibleScore = record.maxPossibleScore;
                
                // 如果没有原始分数但有详细答案，则计算分数
                if (record.detailedAnswers && record.detailedAnswers.length > 0 && 
                    (originalScore === undefined || maxPossibleScore === undefined)) {
                    originalScore = 0;
                    record.detailedAnswers.forEach(answer => {
                        originalScore += answer.score;
                    });
                    maxPossibleScore = record.detailedAnswers.length * 4; // 每题满分4分
                }
                
                // 返回处理后的记录对象
                return {
                    ...record,
                    createTime: formattedTime,
                    originalScore: originalScore,
                    maxPossibleScore: maxPossibleScore
                };
            });
            
            console.log('【历史记录】获取到测试记录数量:', testRecords.length);
            
            // 更新页面数据，显示测试记录
            this.setData({
                testRecords,
                loading: false
            });
            
        } catch (error) {
            // 处理加载失败的情况
            console.error('【历史记录】加载数据失败', error);
            this.setData({ loading: false });
            wx.showToast({
                title: '加载失败，请重试',
                icon: 'none'
            });
        }
    },

    // 格式化日期时间的辅助函数
    formatTime: function(date) {
        if (typeof date === 'string') {
            date = new Date(date);
        }
        const year = date.getFullYear();
        const month = (date.getMonth() + 1).toString().padStart(2, '0');
        const day = date.getDate().toString().padStart(2, '0');
        const hour = date.getHours().toString().padStart(2, '0');
        const minute = date.getMinutes().toString().padStart(2, '0');
        return `${year}-${month}-${day} ${hour}:${minute}`;
    },

    // 查看记录详情的通用处理函数
    viewRecordDetail(e) {
        const recordId = e.currentTarget.dataset.id;
        const record = this.data.testRecords.find(r => r._id === recordId) || this.data.consultationRecords.find(r => r._id === recordId);
        if (record) {
            // 根据当前激活的标签页类型跳转到对应详情页
            if (this.data.activeTab === 'test') {
                this.viewTestDetail(e);
            } else {
                this.viewConsultationDetail(e);
            }
        }
    },

    // 查看测试详情的处理函数
    viewTestDetail(e) {
        const id = e.currentTarget.dataset.id;
        const record = this.data.testRecords.find(item => item._id === id);
        
        if (record) {
            // 检查并重新计算原始分数（如果需要）
            if (record.detailedAnswers && record.detailedAnswers.length > 0 && 
                (record.originalScore === undefined || record.maxPossibleScore === undefined)) {
                console.log('重新计算原始分数');
                
                // 计算用户得分总和
                let originalScore = 0;
                record.detailedAnswers.forEach(answer => {
                    originalScore += answer.score;
                });
                
                // 计算测试最大可能分数
                const maxPossibleScore = record.detailedAnswers.length * 4;
                
                // 更新记录对象的分数信息
                record.originalScore = originalScore;
                record.maxPossibleScore = maxPossibleScore;
                
                console.log('重新计算后的原始分数:', originalScore, '/', maxPossibleScore);
            }
            
            // 将测试记录保存到本地存储，供详情页使用
            wx.setStorageSync('currentTestResult', record);
            
            // 跳转到测试结果详情页
            wx.navigateTo({
                url: `/pages/psychological-test/result/result?id=${id}`
            });
        } else {
            // 找不到记录时显示提示
            wx.showToast({
                title: '找不到测试记录',
                icon: 'none'
            });
        }
    },

    // 查看咨询详情的处理函数
    viewConsultationDetail: function(e) {
        const id = e.currentTarget.dataset.id;
        const record = this.data.consultationRecords.find(r => r._id === id);
        
        if (record) {
            // 存储咨询记录到本地，供详情页使用
            wx.setStorageSync('currentConsultationRequest', record);
            
            // 根据用户角色和记录状态决定跳转页面
            if (this.data.isTeacher && record.status === 'approved') {
                // 教师查看已批准的申请，跳转到结果填写页面
                wx.navigateTo({
                    url: `/pages/consultation/result/result?id=${id}`
                });
            } else {
                // 普通查看详情页面
                wx.navigateTo({
                    url: `/pages/consultation/detail/detail?id=${id}&type=request`
                });
            }
        }
    },

    // 自定义导航栏返回按钮的处理函数
    goBack: function() {
        console.log('返回按钮被点击');
        wx.switchTab({
            url: '/pages/function/function'
        });
    }
})